אוניברסיטת בר אילן מבני נתונים תרגולים מרצה: פרופ' שמואל טומי קליין סמסטר ב', תש"ע

Transcript

1 אוניברסיטת בר אילן מבני נתונים תרגולים (חלקי) מרצה: פרופ' שמואל טומי קליין נכתב ונערך ע"י: גלעד אשרוב סמסטר ב', תש"ע

2 הערות כלליות. המסמך מכיל סיכומי תרגולים שניתנו במהלך הסמסטר (סמסטר ב', תש"ע). המסמך חלקי, כלומר, אינו מכיל את כל התרגולים שניתנו במהלך הסמסטר. אני מקווה שבשנים הקרובות בע"ה אשלים את התרגולים החסרים... אשמח לקבל הערות ותיקונים המסמך נכתב בלאטך לעברית TEX).(L A תודות וקצת קרדיטים. בהזדמנות זו ארצה להודות למתרגל השני צבי קופולביץ', למרצה פרופ' טומי קליין, למתרגלים הקודמים בקורס נטלי שפירא, שי שלומאי ודודי בן חמו. כמו כן, אודה להילה זרוסים, יאיר דומב וארז וייסברד (שישבו לקרוא כמה דפים כדי לבדוק שהם כתובים בסדר). תודה נוספת למיטל לוי, שתירגלה בעבר באוניברסיטת ת"א, שהפנתה אותי לחומר חשוב. השיעור על אסימפטוטיקה מבוסס על תרגולו של דודי בן חמו, השיעור על splay trees מבוסס על שיעור של פרופ' אומן, והשיעור על perfect hash מבוסס על הרצאתו של פרופ' לוינשטיין. השיעור על skip list מבוסס על הרצאתו של,Eric Demaine הניתנת לצפייה ברשת. הספר שעליו עבדנו רוב הסמסטר הוא הספר "מבוא לאלגוריתמים" של קורמן, ריבסט ולייזרסון. 12 ביוני 2010 גלעד אשרוב 2

3 תוכן עניינים 1 ניתוח זמני ריצה 1 2 אסימפטוטיקה חסם אסימפטוטי עליון O חסם אסימפטוטי תחתון. Ω חסם הדוק אסימפטוטית Θ הסימון o הסימון ω השוואת פונקציות סיבוכיות קוד ניתוח לשיעורין דוגמא מחסנית שיטת הצבירה יותר פורמלי שיטת החיובים ("שיטת הבנק") שיטת הפוטנציאל מונה בינארי ניתוח לפי שיטת הצבירה ניתוח לפי שיטת הפוטנציאל מערך דינאמי לקריאה נוספת מחסנית ורשימת דילוגים מבוא מהו מבנה נתונים? רשימת דילוגים Skip - List רעיון ראשון שתי רשימות ובצורה כללית מחסנית דוגמא לשימוש במחסנית בדיקת חוקיות של סוגריים דוגמא לשימוש במחסנית המרת ביטוי מייצוג infix לייצוג postfix Splay Trees סקירה כללית מימוש הפעולה x) splay(t, ניתוח פעולת splay ניתוח פעולת zig-zag ניתוח פעולת zig-zig ניתוח פעולת zig סיום הניתוח

4 10 עצים אדומים שחורים סקירה כללית ניתוח גובה עץ אדום שחור רוטציות הכנסה Universal Hashing and Perfect Hash הערה כללית לפני שמתחילים הקדמה דרישות פונקציית גיבוב מושלמת. Perfect Hash פונקציית hash אוניברסלית בניית פונקציית Perfect Hash עבור. S U FKS - Fredman Komlos Szemeredi

5 תרגול 1 ניתוח זמני ריצה תאריך עדכון אחרון: 12 ביוני מוטיבציה. נתחיל את דיוננו בדוגמא. נתאר שני אלגוריתמים לחישוב סידרת פיבונאצ'י. כלומר, האלגוריתם מקבל כקלט מספר n, וצריך להחזיר fib(n) כאשר הפונקציה fib מוגדרת בצורה הבאה: fib(n) = fib(n 1) + fib(n 2) and fib(1) = fib(2) = 1 נתבונן בשני האלגוריתמים הבאים לפתרון הבעיה: int fib1(int n) { if (n == 1 n == 2) { return 1; } return fib1(n-1) + fib1(n-2); } int fib2(int n) { int preresult = 1, result = 1, temp = 0; for (int i=2; i<n; i++) { temp = result; result += preresult; preresult = temp; } return result; } איזה אלגוריתם הינו יעיל יותר? איך מודדים יעילות של אלגוריתם? על זאת ננסה לענות בשיעור זה. במבני נתונים ובאלגוריתמיקה, אנו נדרשים להציג פתרונות לבעיות המוגדרות היטב. בכדי להעריך את טיב הפתרון, או בכדי להעריך עד כמה הפתרון אופטימלי, נרצה להעריך את מספר הפעולות שהמחשב מבצע בפתרון שהצענו. נרצה לבטא את מספר הפעולות שהמחשב נדרש לבצע כפונקציה של הקלט לבעיה. בכדי להעריך זמן ריצה, אנו נדרשים למספר הנחות מקלות. ראשית, אנו מתבוננים במכונה שבה מעבד יחיד, והפעולות אותן אנו סופרים הן פעולות בסיסיות: השמה, פעולות אריתמתיות (+,, *, /), פעולות בוליאניות, השוואה, גישה לתא במערך וכו'. אנו מניחים שזמן הביצוע של כל פעולה שכזו הוא קבוע. כאמור, נדבר תמיד על מספר הפעולות כפונקציה של אורך הקלט לתוכנית. נעיר כי אלגוריתם כללי לפתרון בעיה צריך לעבוד לכל קלט, ולפיכך דרישה זו הגיונית. לצרוך העניין, ברור כי מיון 5 מספרים הינו קל ומהיר יותר ממיון 1000 מספרים; אם כן, אנו מודדים את טיב האלגוריתם כמספר הפעולות אותו הוא מבצע כפונקציה של אורך הקלט שלו, ולא כפונקציה של מספר הפעולות שביצע בפועל בריצה ספציפית. נעיר כי אלגוריתם יכול לעבוד זמן שונה עבור שני קלטים מאותו האורך. לדוגמא, אם נרצה למיין את הסדרה,1,,2,3,5 4 לעומת הסידרה:,5,,2,3,1 4 סביר (אך לא הכרחי) שאותו אלגוריתם מיון יעבוד "קשה יותר" (זמן רב יותר) עבור הסדרה השנייה שכן הראשונה כמעט וממויינת. לפיכך, על פי רוב, אנו נחשב את מספר הפעולות של האלגוריתם על הקלט הגרוע ביותר שהאלגוריתם יכול לקבל analysis).(worst case 1 נכתב ע"י גלעד אשרוב. הסיכום נכתב בעיקירו על בסיס תרגוליו של דודי בן חמו, 2005, והספר "מבוא לאלגוריתמים" של קורמן, לייזרסון, ריבסט, שטיין ותורגם לעברית ע"י האוניברסיטה הפתוחה. 1

6 נעיר כי לפעמים עורכים ניתוחים על קלט ממוצע לבעיה analysis),(average case וסיבוכיות אלגוריתם יכולה להיות שונה בשני המקרים. ברוב המקרים קשה יותר לנתח מהי הסיבוכיות עבור הקלט הממוצע מאשר סיבוכיות על המקרה הגרוע ביותר. בכל בעיה שנדבר עליה, נציין במפורש מהו גודל הקלט; לדוגמא, במיון מספרים נדבר על מספרים הקלטים, כלומר n. לעומת זאת, אם נרצה לנתח אלגוריתם למכפלת שני מספרים, נדבר על מספר הסיביות הנצרכים לייצוג כל אחד מן המספרים. אם הקלט הוא גרף, נתאר את מספר הפעולות כפונקציה של מספר הקשתות בגרף, או מספר הקודקודים. 2 זמן ריצה. זמן ריצה של אלגוריתם על קלט מסויים הוא מספר פעולות היסוד המבוצעות. נרצה לחשב את סיבוכיות הזמן של אלגוריתם באופן מתמטי כך שנתעלם מאספקטים "טכנולוגיים" כגון מהירות המחשב שעליו מריצים את האלגוריתם (שכן, ברור שכאשר יוצא מחשב חדש מהיר המהיר פי שניים, האלגוריתם שלנו ירוץ מהר פי שניים). "סיבוכיות הזמן" תתאר את סדר הגודל של הפעולות הנדרשות, ותתעלם מקבועים. לצורך פשטות החישוב, נתאר את מושג ה"אסימפטוטיקה", העוזר לנו ל"הפטר" מכל הקבועים. סיבוכיות זיכרון. לעיתים, נרצה למדוד את כמות הזיכרון שבו האלגוריתם משתמש. שוב, נרצה להתעלם מאספקטים "טכנולוגיים", ולכן גם פה נשתמש באסימפטוטיקה. 1.1 אסימפטוטיקה אסימפטוטיקה הינה הערכה של קצב גידול של פונקציה. מה שנותר בחישוב הוא רק האיבר המשמעותי ביותר. למעשה, הדבר שקול לשאלה למה שואף זמן הריצה כשגודל הקלט שואף לאינסוף חסם אסימפטוטי עליון O בד"כ, נרצה לחסום את זמן הריצה "מלמעלה". נניח תוכנית A רצה בזמן f(n) עבור קלט מאורך n. אם O(g(n)),f(n) = אזי מספר הפעולות שהתוכנית עושה הוא סדר גודל של g(n) פעולות לכל היותר. באופן מפורש יותר, שתי ההגדרות הבאות שקולות: הגדרה 1.1 נאמר ש O(g(x)) f(x) = אם ורק אם קיימים שני קבועים, > 0,c x 0 0 כך שלכל x x 0 מתקיים: f(x) c g(x) הגדרה 1.2 נאמר ש O(g(x)) f(x) = אם ורק אם קיים קבוע > 0 c כך ש: lim f(x) x g(x) c כאשר אנחנו אומרים "זמן הריצה הוא ) 2 "O(n הכוונה היא שזמן הריצה במקרה הגרוע ביותר, לקלט הגרוע ביותר, חסום ע"י n 2 c כאשר c הוא איזשהו קבוע. אנחנו בעצם מסתכלים על המקרה הגרוע ביותר. בנוסף, לעיתים רושמים ביטויים כגון: O(n),n 2 + 5n + 2 = n 2 + כלומר, הופכים את + 2 5n ל.O(n) בד"כ כשרושמים ביטויים מסוג זה, מתכוונים שישנו איזשהו O(n) בביטוי שלא ממש מעניין; הגודל המעניין הוא.n 2 יש כאלו שמגדירים את O(g(x)) כמשפחה של פונקציות המקיימות O(g(x)).f(x) = באופן מפורש יותר: O(g(n)) = {f(n) n 0, c 0 such that n n 0 : 0 f(n) c g(n)} במקרה כזה, נאמר כי O(g(n)) f(n) ולא כמו בהגדרה הקודמת O(g(n)).f(n) = אנו נעבוד לפי שתי ההגדרות הראשונות בלבד. 2 בקורסים מתקדמים בתיאוריה של מדעי המחשב, כגון חישוביות וסיבוכיות, אנחנו מחשבים את סיבוכיות האלגוריתם כפונקציה של מספר הביטים הנדרשים לייצוג כל הקלט. על כל פנים, בקורס זה אנו "מרמים" קצת, ומגדירים בכל פעם מהו הפרמטר בקלט שאליו אנחנו מייחסים את הסיבוכיות. 2

7 דוגמאות:.1 נניח שזמן ריצה של אלגוריתם A הוא.f(n) = 10n 2 + 5n אזי, ברור כי ) 2.f(n) = O(n זאת מכיוון שקיים קבוע = 15 c כך שלכל n (קיים = 0 0,x כך שלכל (n > x 0 מתקיים: 10n 2 + 5n < 10n 2 + 5n 2 = 15n 2. ולכן, לפי הגדרה 1.1 נקבל כי ) 2.f(n) = O(n בעזרת הגדרה 1.2 נקבל את אותה התוצאה; נחשב: f(n) lim n g(n) = 10n2 + 5n n 2 = 10 ברור כי 10 הינו קבוע. נציין כי אותה הפונקציה, f(n) מקיימת: O(n!) f(n) = O(n 2 log n), f(n) = O(n 3 ), f(n) = וניתן לחשוב על עוד דוגמאות נוספות (למעשה, כל פונקציה שגדולה מ n). 2 lim n.2 נתבונן בפונקציה.f(n) = n log n 5 + 6n נראה כי n) :f(n) = O(n log f(n) n log n = lim n log n 5 + 6n 5n log n = lim n n log n n n log n + lim n 6n n log n = 5 + lim n 6 log n = 5 ולכן, לפי הגדרה 1.2 אנו מקבלים כי (n.f(n) = O(n log.3 טענה: O(n) n 2 הוכחה: נוכיח בעזרת כל אחת מההגדרות. נתחיל עם הגדרה 1.1: נניח בשלילה שקיים c וקיים n 0 כך שלכל n > n 0 מתקיים: n 2 c n n c בסתירה לכך שהנוסחא מתקיימת לכל n. > n 0 כעת, נראה הוכחה נוספת על סמך הגדרה 1.2: lim n 2 n n = lim n c n לכל קבוע > 0.c חסם אסימפטוטי תחתון Ω לעיתים נרצה לדבר על חסם תחתון לבעיה מסויימת. לדוגמא, ברור שמיון של n מספרים דורש לפחות n פעולה (סתם לבדוק אם המספרים ממויינים עולה סדר גודל של n פעולות). נרצה לחסום את זמן הריצה מלמטה. באופן מפורש יותר, שתי ההגדרות הבאות שקולות: הגדרה 1.3 נאמר ש Ω(g(x)) f(x) = אם קיים קבוע > 0,c וקיים x 0 כך שלכל x x 0 מתקיים: 0 c g(x) f(x) הגדרה 1.4 נאמר ש Ω(g(x)) f(x) = אם קיים קבוע > 0 c כך ש: lim g(x) x f(x) c 3

8 דוגמאות:.1 טענה: Ω(n).3n = הוכחה: נקח = 1.c צ.ל n 0 כך שלכל n n 0 מתקיים: 3n > 1 n 3n 2 n + 5 > 0 הנ"ל פרבולה "מרחפת" ולכן מספיק לקחת = 1 0 n. lim n n 2 3n = טענה: ) 2.3n = Ω(n הוכחה: lim n n 3 3n = > c.3 טענה: ) 3.3n 2 + 5n Ω(n הוכחה: לכל קבוע > 0.c חסם הדוק אסימפטוטית Θ באופן אינטואיטיבי, נאמר ש Θ(g(n)) f(n) = אם מתקיים: O(g(n)) f(n) = וגם Ω(g(n)).f(n) = באופן פורמלי: הגדרה 1.5 נאמר ש Θ(g(n)) f(n) = אם קיימים קבועים > 0 2,c 1, c וקיים קבוע n 0 כך שלכל n n 0 מתקיים: 0 c 1 g(n) f(n) c 2 g(n) הגדרה שקולה: הגדרה 1.6 נאמר ש Θ(g(n)) f(n) = אם קיים קבוע > 0 c כך ש: f(n) lim n g(n) = c דוגמא. נראה ש ) 2 3n = Ω(n לפי שתי ההגדרות. לפי הגדרה,1.5 נקח = 1 1,c 2 = 8,c ו = 0 0.n לכל n > n 0 מתקיים: c 1 n 2 = n 2 3n n 2 = c 2 n 2. 3n lim n n 2 = 3. בכדי להראות זאת לפי הגדרה 1.6, נקבל: טענה 1.7 לכל שתי פונקציות,f(n) f(n) = Ω(g(n)) :g(n) וגם O(g(n)) f(n) = אם ורק אם: = f(n).θ(g(n)) ההוכחה נשארת לקורא כתרגיל (לא שיש יותר מדי מה להוכיח פה..). 4

9 1.1.4 הסימון o כפי שציינו, הסימון O מציין חסם עליון לפונקציה לאו דווקא הדוק. כאשר אנו יודעים בוודאות שהחסם אינו הדוק, ניתן להשתמש ב (o o "קטן"). לדוגמא, נתבונן בפונקציה 5n. נקבל כי O(n) 5n = וגם ) 2 5n, = O(n אך החסם האחרון אינו הדוק אסימפטוטית. במקרה זה נרשום: ) 2 n. = o(n נדגיש כי o(n) 5n. באופן פורמלי, נקבל: הגדרה 1.8 נאמר ש o(g(n)) f(n) = אם לכל קבוע חיובי > 0 c קיים קבוע > 0 0 n כך שלכל n n 0 מתקיים: 0 f(n) < cg(n) הגדרה שקולה: הגדרה 1.9 נאמר ש(( o(g(n f(n) = אם מתקיים: f(n) lim n g(n) = הסימון ω כפי שהגדרנו יחס שבין o קטן לבין O גדול, מציג עכשיו את היחס שבין Ω לבין ω. אנו משתמשים ב ω בכדי לציין חסם תחתון שאינו הדוק אסימפטוטית. לדוגמא, אם הפונקציה היא n 2 אז היא שייכת גם ל ) 2 Ω(n וגם ל.Ω(n) החסם Ω(n) אינו הדוק, ולכן ניתן לרשום ω(n) n, 2 = אך: ω(n) n. הגדרה 1.10 נאמר כי ω(g(n)) f(n) = אם לכל קבוע חיובי > 0 c קיים קבוע > 0 0 n כך שלכל n n 0 מתקיים: 0 cg(n) < f(n) הגדרה 1.11 נאמר ש(( ω(g(n f(n) = אם מתקיים: f(n) lim n g(n) =. השוואת פונקציות למעשה, פונקציות,O,Ω,Θ,o ω הן מעין יחס גדול / קטן: f(n) = O(g(n)) f(n) g(n) f(n) = Ω(g(n)) f(n) g(n) f(n) = Θ(g(n)) f(n) = g(n) f(n) = o(g(n)) f(n) < g(n) f(n) = ω(g(n)) f(n) > g(n) כמובן שכל היחסים >,>,,,= הם אסימפטוטיים, ולא שיוויונים אמיתיים. רבים מן היחסים המתקיימים בין מספרים ממשיים מתקימים גם בהשוואות אסימפטוטיות. 5

10 טרנזיטיביות. אם Θ(g(n)) f(n) = וגם Θ(h(n)) g(n) = אזי Θ(h(n)).f(n) = אם O(g(n)) f(n) = וגם O(h(n)) g(n) = אזי O(h(n)).f(n) = אם Ω(g(n)) f(n) = וגם Ω(h(n)) g(n) = אזי Ω(h(n)).f(n) = אם o(g(n)) f(n) = וגם o(h(n)) g(n) = אזי o(h(n)).f(n) = אם ω(g(n)) f(n) = וגם ω(h(n)) g(n) = אזי ω(h(n)).f(n) = רפלקסיביות. f(n) = Θ(f(n)) f(n) = O(f(n)) f(n) = Ω(f(n)) סימטריה. Θ(g(n)) f(n) = אם ורק אם Θ(f(n)).g(n) = בנוסף, נשים לב: constants : n 1 c+1 < 1 n c < 1 log n < 1 <... logarithms : < log n < (log n) k <... polynomials : < n < n < n log n < n k < n k+1 <... exponentials : < 2 n < n! < n n שאלה: בהינתן,f(x),g(x) האם תמיד מתקיים O(f(x)) g(x) = או O(g(x))?f(x) = תשובה: לא. נתבונן ב,f(n) = n 1+sin n וב.g(n) = n לא ניתן להשוות בינהם אסימפטוטית. שאלה: האם לכל פונקציה f(n) קיימת פונקציה "סטנדרטית".).., 2 g(n) (n, n log n, n כך ש = f(n)?θ(g(n)) תשובה: לא. נתבונן ב f(n) המוגדרת באופן הבא: { n n odd f(n) = n 3 o.w תרגיל 1.12 הוכח: n) log(n!) = Θ(n log הוכחה: מתקיים: ( n ) ( n ) log(n!) = log ( n) = log i < log n = log n n = n log n 6 ולכן n).log(n!) = O(n log

11 log(n!) = log ( n) = > log i > נותר להראות כי קיים c עבורו:.log(n!) > cn log n נקבל: n 2 1 log i = log i + log i i= n 2 log n 2 = n 2 log n 2 = n (log n log 2) 2 i= n 2 i= n 2 = n 2 (log n 1) = n 2 log n n 2. n 4 log n > n 2 נקבל כי לכל ה nים המספיק גדולים: כאשר > 4 n נקבל כי: > 2 n,log ולכן log(n!) > n 2 log n n 2 > n 2 log n n 4 log n = n 4 log n = 1 4,c ו = 4 0,n נקבל כי לכל n > n 0 מתקיים:,log(n!) > c n log n כלומר ולכן, כאשר log(n!) = Θ(n log n) נסיק אם כן כי.log(n!) = Ω(n log n) 1.2 סיבוכיות קוד ניתן ללמוד את סיבוכיות האלגוריתם מתוך מבט כללי על מבנה הקוד. לפי מספר הלולאות שהקוד מבצע, לפי קריאות רקורסיביות, וכו'. דוגמא: נתבונן בקוד הבא: for (unsigned u=0; u<n; ++u) { basic_step1; basic_step2; } ישנה לולאה שרצים עליה n פעמים, בכל פעם מבצעים 2 פעולות, ולכן סיבוכיות הקוד הינה 2n, כלומר.(Θ(n) (למעשה O(n) for (unsigned u=0; u<10; ++u) { basic_step1; basic_step2; } 9 2 = 20 u=0 דוגמא נוספת: נתבונן בקוד הבא: מספר הפעולות שהאלגוריתם מבצע הוא: ולכן, נקבל (1)O. for (int i = n; i > 0; --i) { for (unsigned j=0; j<n; ++j) { basic_step; } } עוד דוגמא: נתבונן בקוד הבא: 7

12 n 1 1 = j=0 n = n 2 כלומר, ) 2.O(n ועוד אחת: נתבונן בקוד הבא: for (int i = 1; i <= n; i*=2) { basic_step; } בכל איטרציה מבצעים בדיוק פעולה אחת. כמה איטרציות יש לנו? נעקוב אחרי i: הערכים אותם הוא מקבל:, n... 8,.1, 2, 4, יש לנו למעשה סידרה הנדסית עם הפרמטרים: = 1 1.q = 2,a k = n,a לפי נוסחא לסידרה הנדסית: k 1,a k = a 1 q כלומר:,n = 1 2 k ולכן.k = log n כלומר, מספר האיטרציות הוא.log n מכיוון שבכל איטרציה מבצעים פעולה אחת, נקבל כי הסיבוכיות היא: (n.o(log מה קורה כאשר הלולאות תלויות אחת בשניה? לדוגמא, נתבונן בקוד הבא: for (int i = 1; i <= n; i *= 2) { for (j = 1; j <= i; j++) { basic_step; } } במקרה זה לא נוכל סתם לכפול את הלולאה החיצונית בלולאה הפנימית; נתבונן קודם בניתוח לא מדויק: הלולאה החיצונית מתבצעת log n פעמים, הלולאה הפנימית מתבצעת במקרה הגרוע ביותר n פעמים, ולכן נקבל בסה"כ (n.o(n log הנ"ל אינו חסם הדוק! בכדי לקבל חסם הדוק, נחשב לפי סיגמאות. נשים לב כי i מקבל ערכים, n...,8,1,,2,4 לפיכך, נגדיר משתנה k שירוץ מ 0 ועד ל,log n ונגדיר את i להיות 2. k נקבל: log n k=0 j=1 i 1 = log n 2 k k=0 j=1 1 = log n k=0 2 k = 2 log n+1 1 = 2 2 log n 1 = 2n 1 = Θ(n) כלומר, הסיבוכיות היא לינארית. 8

13 תרגול 3 ניתוח לשיעורין תאריך עדכון אחרון: 12 ביוני ניתוח לשיעורין analysis) (amortized הוא טכניקה לניתוח זמן ריצה לסדרת פעולות, אשר מאפשר קבלת חסמי זמן ריצה נמוכים יותר מאשר חסמים המתקבלים כאשר מניחים את המקרה הגרוע ביותר בכל פעולה. בדרך כלל אנחנו מתייחסים למספר פעולות, כאשר חלק מהפעולות יקרות יותר, וחלקן זולות יותר. בניתוח לשיעורין אנו מדברים על עלות כל פעולה בממוצע, עבור כל רצף של פעולות אפשרי של שימוש במבנה הנתונים. אנו מדברים על המקרה הגרוע ביותר; כלומר, לוקחים בחשבון את הסידרה הגרועה ביותר של פעולות שיכולה להיות. ניתוח לשיעורין היא איזושהי אסטרטגיה לניתוח כל רצף של פעולות המראה שממוצע העלות לכל פעולה הוא קטן, למרות שישנן פעולות יחידות בתוך הרצף שעלולות להיות יקרות. נעיר שלמרות שאנו מדברים על ממוצעים, אנו לא מערבים הסתברויות בניתוח. המטרה היא חישוב חסם עליון הדוק ככל שניתן לעלות של רצף כלשהו של n פעולות. נניח עלות הפעולה.T (n)/n אזי עלות כל פעולה בממוצע היא.T (n) = n ה i היא c, i המטרה היא לחשב 1=i c i נראה שלוש שיטות לניתוח לשיעורין שיטת הצבירה, שיטת החיובים (שיטת ה"בנק") ושיטת הפוטנציאל. שיטת הפוטנציאל היא החשובה ביותר. 3.1 דוגמא מחסנית נתבונן במחסנית התומכת בפעולות הבאות: (1)O. למחסנית. עלות x מכניס את push(x) (1)O. להוציא את האיבר האחרון שנכנס (אם יש כזה). עלות pop(x) multi pop(x) מוציאה את כל האיברים מהמחסנית. עלות: אם יש k איברים כרגע במחסנית אזי.O(k) נממש (בפסאדו קוד) את :multi pop() multi-pop() while not isempty() pop() נשים לב שכל הפעולות עולות (1)O, מלבד הפעולה.multi pop בפרט, הפעולה הנ"ל נראית יקרה היא לינארית במספר האיברים במחסנית. כך, אם ישנם n איברים במחסנית, עלותה O(n) (מה שנשמע רע מאוד ביחס ל (1)O). אבל האם אנחנו לא מחמירים מדי כשאנו מנתחים את הפעולה בצורה כזו? כדי לחדד את השאלה, נתבונן בניתוח השגוי הבא. נשאל עבור סידרה של n פעולות מהי העלות worst case לסידרה. כעת, יכולים לטעון (בטעות) שכל פעולה מסוג multi pop עולה O(n) בכל פעם, ולכן בסה"כ רצף של n פעולות עלול להגיע ל ) 2.O(n אך, ניתוח זה לא הדוק. אצלינו, בכדי שיהיו n איברים במחסנית, צריכים להיות n פעולות push לפני כן. אם נתונים לנו רצף של פעולות מסוימות, נניח n פעולות push ולאחריהן פעולת multi pop עבור n פעולות ה push אנחנו משלמים n בסה"כ, ועל פעולת multi pop אנו משלמים n. כלומר בסה"כ אנו משלמים עבור רצף + 1 n 9

14 הפעולות 2n, מה שאומר שבממוצע לכל פעולה אנו משלמים 2. כלומר, העלות הממוצעת לכל פעולה היא.O(1) כעת נראה שיטות ואסטרטגיות לחישוב של ניתוח לשיעורין. 3.2 שיטת הצבירה בשיטת הצבירה אנו מראים שלכל n, סדרה של n פעולות צורכת זמן של (n) T לכל היותר. נקבל אם כן, שממוצע זמן של כל פעולה, או העלות לשיעורין של כל פעולה, הינה T. (n)/n זוהי העלות לשיעורין של כל פעולה גם כאשר הסידרה מכילה סוגים שונים של פעולות. בדוגמת המחסנית ננתח כמה עולה n פעולות על המחסנית. יש שלוש פעולות אפשריות:,pop,push.multi pop אמנם multi pop עולה O(n) במקרה הגרוע, אך נשים לב שכל עצם ניתן לשלוף רק פעם אחת עבור כל פעם שהוא נדחף למחסנית. לכן, מספר הקריאות ל pop (גם אלו שבתוך המימוש של (multi pop הוא לכל היותר מספר הקריאות ל.push מכיוון שאנו מתבוננים בסידרה מאורך n, אין יותר מ n קריאות ל,push ולפיכך מספר הקריאות הכולל ל pop (גם אלו שבתוך (multi pop הוא לכל היותר n. נקבל כי העלות הכוללת היא לכל היותר 2n, ולכן בממוצע עלות כל פעולה היא 2, כלומר (1)O יותר פורמלי הקבוצה שלי ביום רביעי ראתה את זה, וכמו כן, הקבוצות של צבי. הורדתי את זה בשיעורים ביום ראשון בכדי להעביר את העיקר. אתם נדרשים לקרוא ולנסות להבין את ההוכחה. בשיטת הצבירה אנו מחשבים סכום כל העלויות עבור סידרה כללית של פעולות. מכיוון שאנו מתבוננים על סידרה כללית, הניתוח יכסה גם את הסידרה הגרועה ביותר. בכדי לדבר על סידרה כלשהי נתבונן בסידרה כללית של פעולות: S = (σ 1, σ 2,..., σ n ) כל פעולה {3,1},2 i σ, כאשר 1 מציין את הפעולה,push 2 מציין,pop ו 3 מציין.multi pop אם עלות הפעולה ה i היא c, i נרצה לחשב: T (n) = נתבונן בכל המקומות בסידרה כך ש = 3 i.(multi pop) σ נניח שכל הפעולות הנ"ל נמצאות במקומות } t,i = {i 1,..., i וכך ש.i 1 < i 2 <... < i t (נעיר שאם I ריקה, אזי (n) T הוא סכום של קבועים (אין פעולת (multi pop ולכן הסכום כולו לינארי ב n). בנוסף, נגדיר כי = 0 0 i. נסמן את סידרת הפעולות של S בין המקומות 1 j i ובין i j ב S. ij כלומר, הסידרה: k=1 c k S ij = {σ ij 1 +1,..., σ ij } כעת, נראה את הטענה הבאה: טענה 3.1 לכל j t,1 עלות הפעולה multi pop הנמצאת במקום i j (כלומר, עלות הפעולה (σ ij הינה.2(i j i j 1 1) הינה S ij לכל היותר. בנוסף, עלות הסידרה i j i j 1 1 הוכחה: יהי j נתון. לאחר הפעולה ij 1 σ המחסנית ריקה (שכן, פעולה זו הייתה פעולת.(multi pop כל שאר הפעולות אינן פעולות multi pop (חתכנו את סדרת הפעולות בין זוג פעולות.(multi pop לכן, לכל פעולה בסדרה הנ"ל, הפעולה היא push או.pop במקרה הגרוע ביותר כל הפעולות הן,push מה שאומר שכאשר מגיעים לפעולה σ ij (פעולת ה (multi pop ישנם 1 j 1 i j i איברים במחסנית. לפיכך, העלות של פעולת ה multi pop היא 1 j 1 i. j i לכן, העלות הכוללת לסידרה S ij היא לכל היותר 1) j 1.2(i j i 10

15 כעת, לכל סידרה S ניתן להתייחס ל } t.i = {i 1,..., i נקבל: t T (n) 2(i j i j 1 1) + c j = 2(i t i 0 ) 2t + (n i t ) j=1 j=i t+1 נזכור ש i t הינו איזשהו אינדקס בתחום i t n 1, וכמו כן i 0 הינו 0. לפיכך: T (n) = 2(i t i 0 ) 2t + (n i t ) = 2i t 2t + n i t = n + i t 2t 2n 2t 2n כלומר, הצלחנו להראות שלכל סידרה של פעולות מאורך n, העלות הכוללת היא לכל היותר 2n. הנ"ל מראה שעלות ממוצעת של כל פעולה היא (1)O. 3.3 שיטת החיובים ("שיטת הבנק") בשיטה זו ניתן לכל פעולה עלות שונה מזו שהיא עולה באמת. עלות זו נקראת "עלות לשיעורין". חלק מהפעולות יקבלו עלות גדולה יותר מהעלות האמיתית שלהן; חלק מהפעולות יקבלו עלות קטנה יותר מזו שהן עולות בפועל (בדרך כלל, הפעולה היקרה ביותר בפועל תקבל את העלות הקטנה ביותר לשיעורין). העיקרון שצריך תמיד לשמור עליו, הוא שסידרה של n פעולות (לכל n) לפי העלויות לשיעורין שלנו תהיה גדולה יותר מהעלות האמיתית שלהן בפועל. נשתמש ב"בנק" בשביל "לשמור" לנו עלויות. נניח שעל פעולת push אנחנו משלמים 2 יחידות במקום יחידה אחת; יחידה אחת תהיה העלות האמיתית של הפעולה (שהיינו צריכים לשלם ממילא), והיחידה השנייה פשוט תכנס ל"בנק" בשביל "התחשבנות עתידית". כעת, כאשר נבצע פעולת multi pop לא נשלם מ"הכיס" אלא נמשוך את העלויות שצברנו בבנק; מכיוון שעל כל איבר שיש כרגע במחסנית כבר צברנו יחידה אחת בבנק, נקבל כי יש בבנק מספיק כסף בשביל לממן את הפעולה,multi pop ולכן לא נשלם עבור פעולה זו מהכיס בכלל. הסבר נוסף כאשר אני מכניס איבר למחסנית (ומשלם עליו 1), אני משלם גם עבור ההוצאה שלו כבר בזמן ההכנסה (עוד יחידה אחת). לכן, בסה"כ הכנסה עולה 2 יחידות; כעת, הוצאה יחידה, או הוצאה ע"י multi pop הן למעשה בחינם (שילמנו עליהן קודם; בבנק יש מספיק כסף בשביל לשלם על ההוצאה שלהן). יותר פורמלי. נסמן ב ĉ i את העלות לשיעורין של הפעולה ה i. נסמן ב c i את העלות האמיתית של הפעולה ה i. העלות לשיעורין של הפעולה ה i בשיטת הבנק הינה: ĉ i = c i + deposit withdraw כלומר עלות הפעולה היא העלות האמיתית + ההפקדה שאנו מבצעים לבנק, פחות העלות של המשיכה (במידת הצורך). כאשר אנו שומרים על העיקרון שלעולם "לא ניכנס למינוס" (לעולם לא נמשוך מהבנק סכום כסף שלא הפקדנו אותו לפני כן), מתקיים שסך כל ההפקדות (סכום כל הערכים של (deposit גדול מכל הפעמים שמשכנו מהבנק (סכום כל הערכים שביצענו,(withdraw ולכן: ĉ i c i = T (n) כלומר, העלות האמיתית של n הפעולות היא קטנה מסכום העלות לשיעורין. כעת, ננתח כל אחת מפעולות המחסנית: 11

16 עבור פעולת push עלות הפעולה היא 1, בנוסף, מכניסים 1 לבנק. נקבל: ĉ i = = 2 עבור פעולת pop עלות הפעולה היא 1. לא מפקידים לבנק, ולא מושכים ממנו. 1 נקבל: ĉ i = = 1 עבור פעולת multi pop נניח שמספר האיברים כרגע הוא k. עלות הפעולה אם כן היא k. כעת, נמשוך מהבנק k יחידות (בדוק שהבנת מדוע אנו בטוחים כי בבנק יש k יחידות). נקבל: ĉ i = k + 0 k = 0 אם כן, העלות לשיעורין של כל פעולה קטן מ 2. מכיוון שלעולם לא נכנסים למינוס, נקבל כי: ĉ i c i = T (n) T (n) ĉ i 2n אצלינו, לכל.ĉ i 2,i כלומר: ולכן סכום התשלומים עבור n פעולות קטן מ 2n. כלומר, העלות הממוצעת לכל פעולה היא 2. חשוב לציין שכאשר מבצעים ניתוח בשיטת הבנק חייבים תמיד לשמור על האינווריאנטה שסכום הכסף בבנק הוא חיובי. אסור בשום אופן "להכנס למינוס", שכן כאשר אנו "נכנסים למינוס" העלות האמיתית של הפעולות היא פחות מהעלות לשיעורין שאנו מבצעים, ואז לא נוכל לטעון שהעלות הכוללת של העלויות לשיעורין גדולה מהעלויות האמיתיות. 3.4 שיטת הפוטנציאל שיטת הפוטנציאל דומה מאוד לשיטת הבנק, רק שאנו ממדלים אותה באופן יותר מתמטי, ולכן היא יותר פורמלית (ופחות אינטואיטיבית..). בשיטת הבנק "התשלום מראש" היה שמור כיתרה לזכותם של עצמים ספציפיים במבנה הנתונים (כל איבר שמר לעצמו את העלות להוצאתו בעתיד). כאן, ה"תשלום מראש" מובע בעזרת "אנרגיה פוטנציאלית" שניתן לשחרר כדי לשלם עבור פעולות בעתיד. כמו בשיטת הבנק פעולת push תגדיל לנו את הפוטנציאל של מבנה הנתונים (ונשלם על הגדלה זו), ופעולת multi pop תשולם בעזרת "פירוק הפוטנציאל הזה", או, ריקון הפוטנציאל (ואין צורך לשלם עליה כי כבר שילמנו על הפוטנציאל עצמו). 1 יכולנו להגדיר שגם במקרה זה אנו מושכים את העלות מהבנק, ולא משלמים מהכיס. במקרה זה נקבל כי העלות לשיעורין היא 0. נציין שעדיין לא נכנס למינוס, וכל המשך הניתוח הוא בדיוק אותו הדבר. 12

17 שיטת הפוטנציאל. יהי D 0 המצב ההתחלתי של מבנה הנתונים שעליו מבוצעות n פעולות. נסמן ב c i את העלות של הפעולה ה D i i. הינו המצב של המערכת לאחר הפעולה ה i, על המצב 1 i D. כלומר, מתחילים ממצב D, 0 מבצעים פעולה כלשהי ) 1 σ) ומגיעים למצב D. 1 לאחר מכן מבצעים פעולה כלשהי ) 2 σ) ומגיעים למצב D, 2 וכן הלאה. פונקציית הפוטנציאל φ ממפה כל מצב של מבנה הנתונים D i למספר ממשי שמציין את הפוטנציאל המיוחס למבנה הנתונים. נגדיר את העלות לשיעורין של הפעולה ה i כ: ĉ i = c i + φ(d i ) φ(d i 1 ) כלומר, העלות לשיעורין של הפעולה ה i היא העלות האמיתית + c i הפרש הפוטנציאלים של מבנה הנתונים. במילים אחרות, העלות האמיתית של הפעולה ה i הינה: העלות של כל סידרה כלשהי של n פעולות: T (n) = = = c i = ĉ i + φ(d i 1 ) φ(d i ) c i = ĉ i + [ĉ i + φ(d i 1 ) φ(d i )] [φ(d i 1 ) φ(d i )] ĉ i + φ(d 0 ) φ(d n ) כאשר הצעד האחרון נכון מכיון שהטור הינו טלסקופי. אם תמיד יתקיים ) n,φ(d 0 ) φ(d נקבל כי : כלומר, T (n) = ĉ i + φ(d 0 ) φ(d n ) T (n) = c i ĉ i ĉ i גם פה, כמו בשיטת הבנק, אנו שומרים על כך שסכום עלות n פעולות קטן יותר מסכום ה"עלות לשיעורין". לכן, הניתוח הופך לפשוט יותר: כל שצריך הוא לחשב את ĉ i לכל אחת מהפעולות הקיימות על מבנה הנתונים. ניתוח מחסנית בעזרת שיטת הפוטנציאל. (= מצב D) i במחסנית. נקבל: ובנוסף: נגדיר את פונקציית הפוטנציאל ) i φ(d כמספר האיברים שיש כרגע φ(d 0 ) = 0 1 i n, φ(d i ) 0 כלומר, פונקציית פוטנציאל זו טובה ועונה על הדרישה. הפיתוח הנ"ל אומר לנו שבכדי להראות שהעלות הממוצעת של כל פעולה בכל סדרה הינו קבוע, מספיק להראות ש ĉ קבוע. לכן, נחשב עבור כל אחד מסוגי הפעולות. עבור פעולת push עלות הפעולה הוא 1, ונניח שהיו t איברים במחסנית. לאחר הפעולה, ישנם + 1 t איברים במחסנית. נקבל: ĉ i = c i + φ(d i ) φ(d i 1 ) = 1 + (t + 1) t = 2 13

18 עבור פעולת pop עלות הפעולה הוא 1, ונניח שהיו t איברים במחסנית. לאחר הפעולה, ישנם 1 t איברים במחסנית. נקבל: ĉ i = c i + φ(d i ) φ(d i 1 ) = 1 + t 1 t = 0 עבור פעולת.multi pop נגיד שיש כרגע t איברים במחסנית. אזי, עלות הפעולה הוא t, ומצד שני הפרש הפוטנציאלים הוא t (לפני הפעולה היו t איברים במחסנית, ולאחריה 0). נקבל אם כן: ĉ i = c i + φ(d i ) φ(d i 1 ) = t + 0 t = 0 T (n) = c i ĉ i 2 = 2n נקבל: ולכן העלות הממוצעת של כל פעולה מונה בינארי נניח יש לנו מונה עם k ביטים, הסופר בבינארית. אנחנו למעשה תומכים רק בפעולה אחת increment העלה ב 1. עלות כל פעולה = מספר הביטים שהוחלפו. לדוגמא: (לצד כל ערך בינארי מצויין עלות פעולת ה (increment כמה עולה הפעולה?increment כמה עולה רצף של n פעולות? שוב, ניתוח שגוי יאמר כי בכל פעם, במקרה הגרוע ביותר אנו מבצעים O(k) החלפות (שכן יש k ביטים במונה. במקרה הגרוע ביותר נחליף את כל הביטים במונה). ולכן, במקרה הגרוע ביותר (n.o(k ניתוח זה שגוי. נבצע ניתוח לשיעורין ניתוח לפי שיטת הצבירה במקרה זה, מכיוון שישנה רק פעולה אחת (increment) הניתוח לפי שיטת הצבירה פשוט. כל רצף של פעולות נראה בדיוק אותו הדבר. נתבונן על n פעולות. הביט הראשון יתחלף n פעמים (בכל פעם). הביט השני לעומת זאת, יתחלף בכל n 2 פעמים. הביט השלישי יתחלף כל פעם רביעית, כלומר בסה"כ ב n 4 פעמים. הביט ה פעם זוגית, כלומר ב 14

19 n i יתחלף i 1 2 פעמים. כלומר: T (n) = number of bits that were changed k [ ] = number of times that the i th bit was changed = k n k 2 i 1 = n 1 2n 2i 1 כלומר, 2 (n)/n.t ניתוח לפי שיטת הפוטנציאל נגדיר פונקציאת פוטנציאל: ) i = φ(d מספר האחדות במונה. 2 מתקיים: = 0 ) 0,φ(D ולכל i n 1 נקבל: 0 ) i,φ(d ולכן פונקציית פוטנציאל זו עונה על הדרישה שלנו. נראה כמה עולה פעולת.increment כאשר מבצעים פעולת,increment האפס הראשון מימין הופך ל 1, וכל שאר האחדות מימין אליו מתאפסים. נניח שישנם t אחדות רצופים מסוף המונה (מימין). במצב כזה, עלות פעולת increment תהיה + 1 t (שכן נשנה את t האחדות לאפסים, ואת האפס שלאחריהם ל 1). מצד שני, נשים לב שכעת יש פחות 1 t אחדות בביטוי (שכן t אחדות הפכנו לאפסים, ואפס אחד הפכנו ל 1). נקבל: ĉ i = c i + φ(d i ) φ(d i 1 ) = t + 1 (t 1) = 2 לכן, רצף של n פעולות יעלה פחות מ 2n. כלומר, הממוצע לכל פעולה מערך דינאמי המערך תומך בפעולת insert ומכניס את האיבר למקום הפנוי הבא. נניח שבמערך יש n מקומות, ונניח שהמערך מלא. כעת, כאשר נבקש להוסיף איבר נוסף, נבצע את הפעולות הבאות: נקצה מערך בגודל 2n. נעתיק את n האיברים הישנים. נוסיף את האיבר החדש במקום + 1 n. הנחה: זמן הקצאה: (1)O. שוב, נעיר שניתוח של n פעולות יכול להיות שגוי במקרה הגרוע ביותר, insert עולה,O(n) ולכן n פעולות יעלה ) 2.O(n שוב, הניתוח הנ"ל שגוי מכיוון שכדי באמת להגיע לפעולה שעולה,O(n) צריך לבצע קודם לכן n פעולות שעולות (1)O כל אחת, ולכן ממוצע כל פעולה הוא קבוע. ננתח בעזרת שיטת הפוטנציאל בלבד. בשיטת הפוטנציאל, ננסה לתת מוטיבציה לבחירת פונקציאת הפוטנציאל. ככל שיש יותר איברים במערך הסיכוי שנצטרך להעתיק אותו למערך חדש הוא גדל. "הפוטנציאל" המצטבר במערכת הוא יותר גדול, ולכן נרצה לשלם על כך מראש (כדי שפירוק הפוטנציאל יהיה "בחינם"). אם כן, נרצה לבדוק עד כמה אנו קרובים לנקודת פירוק הפוטנציאל. לשם כך נשתמש בשני משתנים num ו num.size ישמור את מספר האיברים שיש כרגע במערך. size ישמור את אורך המערך. נשים לב שכאשר size = num בהכנסה הבאה נצטרך לפרק את הפוטנציאל. כלומר, כאשר + 1 size num = נצטרך להגדיל את size פי שתיים. בנוסף, כאשר size 2 num נקבל כי הגדלנו את מבנה הנתונים פי שתיים רק זה מכבר, ונרצה שבנקודה זו ערך הפוטנציאל יהיה 0. ככל שיכניסו יותר איברים ערך הפוטנציאל יעלה, עד אשר נגיע למצב.num = size כאן נרצה שערך הפוטנציאל יהיה מספיק בשביל לשלם עבור ההרחבה הבאה. 2 במדעי המחשב, הפונקציה שסופרת את מספר האחדות בביטוי בינארי נקראת "משקל המינג". 15

20 פונקציית פוטנציאל שמתארת את הדרישות שלנו היא: φ(d i ) = 2 num size מכיוון שהמערך תמיד מלא בלפחות חצי מהאיברים 2num) (size נקבל כי לכל φ(d i ) i חיובי. בנוסף, = 0 ) 0.φ(D כלומר, פונקציה זו עונה על הדרישה. כלומר, אם גודל המערך הוא 16, ויש לנו 9 איברים, ערך הפוטנציאל הוא 2. כאשר נגיע ל 16 איברים, ערך הפוטנציאל יהיה כבר 16, ופירוקו ישלם לנו עבור ההעתקה למערך החדש. כעת נחשב את העלות לשיעורין. נחלק לשני מקרים: אם הפעולה ה i לא גורמת להרחבת מבנה הנתונים, נקבל כי i 1 c i = 1,size i = size ו = i num i num לכן: ĉ i = c i + φ(d i ) φ(d i 1 ) = num i size i (2 num i 1 size i 1 ) = (num i 1 + 1) size i 2 num i 1 size i 1 = num i 1 2 num i 1 = 3 אם הפעולה ה i כן גורמת להרחבת מבנה הנתונים, נקבל כי 1 i size i = 2 size (אנו מגדילים את גודל המערך פי שניים). כמו כן, 1 i + 1 c i = num i = num העלות של הפעולה ה i היא העתקת 1 i num איברים, והכנסת איבר נוסף אחד. מספר האיברים כעת הוא 1 i + 1.num i = num לבסוף, מכיוון שהמערך הועתק נקבל כי המערך היה מלא. כלומר 1 i.num 1 i = size אם כן: ĉ i = c i + φ(d i ) φ(d i 1 ) = num i + 2 num i size i (2 num i 1 size i 1 ) = 3 num i size i 2 num i 1 + size i 1 = 3 num i 2(num i 1) 2 size i 1 + size i 1 = 3 num i 2 num i + 2 size i 1 = num i size i = = 3 שכן, מספר האיברים כרגע במערך ) i (num גדול מאחד מגודל המערך לפני ההגדלה. קיבלנו כי לכל סוג של פעולה 3 ĉ, ולכן, העלות הכוללת של כל סידרת פעולות היא: T (n) = c i ĉ i 3 = 3n ולכן, העלות הממוצעת לכל פעולה היא = 3 (n)/n T. 3.7 לקריאה נוספת תורגם לעברית ע"י "מבוא לאלגוריתמים", הוצאת M IT (ראה [2]). קורמן, לייזרסון, ריבסט: האוניברסיטה הפתוחה. 16

21 תרגול 4 מחסנית ורשימת דילוגים תאריך עדכון אחרון: 12 ביוני לשים לב! הסיכום הפעם לא מכיל את כל החומר שנלמד בשיעור; יש להשלים מהדברים שלמדנו בכיתה. כמו כן, הסיכום אינו מכיל ציורים שכנראה הכרחיים לשם הבנת החומר. 4.1 מבוא מהו מבנה נתונים? מבנה נתונים הוא דגם המגדיר את היחסים בין הנתונים ואת הפעולות המבוצעות עליהם. אנו מראים אילו פועלות ניתן לבצע על מבנה הנתונים, וכיצד מנהלים אותו. אנו נפריד בין שני סוגים של פעולות על מבנה הנתונים "שאילתות",(queries) כלומר החזרת מידע על מבנה הנתונים, לבין פעולות "שינוי" modifying) (operations שבהם משנים את מבנה הנתונים עצמו. לאחר בניית מבנה הנתונים, אפשר להתחייס למבנה הנתונים כ דינאמי, כלומר מגדירים כיצד יבוצעו פעולות השינוי, לעומת זאת, ניתן להתייחס על מבנה נתונים סטאטי, שבו לא מגדירים פעולות שינוי, אלא מניחים שברגע שמבנה הנתונים כבר בנוי וכל הפעולות שיתבצעו עליו יהיה מהסוג "שאילתות". לדוגמא, ניתן להגדיר את מבנה הנתונים S ועליו להגדיר את הפעולות הבאות: S. במבנה הנתונים x מחפש אחר האיבר Search(S, (x Min(S) מחזיר את האיבר ב S בעל המפתח הקטן ביותר. S. למבנה הנתונים x מכניס את האיבר Insert(S, (x.s ממבנה הנתונים x מוציא את Delete(S, x) נשים לב שהפעולות Insert, Delete הינן פעולות "שינוי", בעוד שפעולת Search ו Min אלו פעולות מסוג "שאילתות". על מנת לתאר את מבנה הנתונים, תחילה נתאר אותו באופן אבסטרקטי (מערכת הקשרים על הנתונים, ומהן הפעולות שיש לבצע על הנתונים). לאחר מכן, מגדירים את האלגוריתם לכל אחת מן הפעולות בפסאדו קוד. 1 בד"כ בשלב זה נרצה להעריך את סדר גודל כל פעולה שהגדרנו, ונרצה לשפר את מבנה הנתונים כך שיתאים בצורה אופטימלית לפעולות שאותן אנחנו ממשים. את שני השלבים האלה נעשה ברוב הקורס. לבסוף, בכדי להשתמש בפועל במבנה הנתונים, נצטרך לממש את מבנה הנתונים בשפת תוכנה מסוימת, לדוגמא.C רשימת דילוגים Skip - List בשלב זה אנו מניחים כי הסטודנטים מכירים את מבני הנתונים רשימה מקושרת, מחסנית, תור, וכמו כן כיצד לממש מבני נתונים אלו, מה ההבדל בין מימוש בעזרת מערך ובין מימוש בעזרת רשימה מקושרת. 1 כלומר, כותבים את הפתרון בצורה טכנית הנראית כמו קוד, אך לא מתייחיסים לפרטים קטנים ומעצבנים של מימוש בשפת תוכנה מסויימת. בעוד שקוד רגיל צריך לדעת לקרוא מחשב, את הפסאדו קוד צריכים לקרוא בני אדם, ולכן צריך לכתוב תוכנית בצורה שיהיה ברור מה מנסים לכתוב. 17

22 בניגוד למבני נתונים שנלמד בהמשך הקורס, שבהם נתקל בפרטים קטנים שלפעמים קשים לזכירה רשימת דילוגים הוא מבני נתונים פשוט וקל לזכירה. מבני הנתונים הזה הוא כנראה גם החדש ביותר שנלמד בקורס, ופורסם ע"י P ugh ב ראה [4]. נדבר על הפעולה.search(x) אם נשמור את הנתונים בתוך מערך ונשמור תמיד שהמערך יהיה ממוין, חיפוש יעלה לנו (n O(log (ניתן לבצע חיפוש לינארי). גם אם x לא נמצא בקבוצה, נוכל להחזיר את הקודם או העוקב במבנה הנתונים. הבעיה במערך היא הכנסה והוצאה. כל עוד שומרים שהמערך ממוין, בכדי להכניס איבר בין שני איברים יש צורך "להזיז" את שאר האיברים במערך, מה שיכול להעלות.O(n) כנ"ל לגבי הוצאה. אם עוברים לרשימה מקושרת בעיית ההכנסה וההוצאה נפתרת. אך כעת, גם כאשר הרשימה ממויינת לא ניתן לבצע חיפוש איבר בזמן (n.o(log זאת מכיוון שלא ניתן לבצע גישה ישירה לאיבר במקום ה i (רשימה מקושרת לא תומכת ב.(random access אם כן, נרצה לשפר את החיפוש ברשימה מקושרת; נרצה לבצע מעין חיפוש בינארי ברשימה מקושרת. נדבר כרגע רק על מבנה נתונים סטטי. כלומר כל האיברים כבר נתונים וידועים מראש, והפקודה היחידה שעליה אנו מדברים היא search(x) פעולת שאילתא (נעיר שהסיבה היחידה שבה אנו מדברים על רשימת דילוגים ולא על מערך היא מכיוון שאנו בכל זאת רוצים לדבר על insert ו,delete ולכן ההתמקדות במבני נתונים סטטי נראה תמוה; על כל פנים, נראה את רעיון מבני הנתונים, ונציין לאחר מכן כיצד מבצעים את הפעולות הנ"ל. כלומר, כיצד הופכים את מבנה הנתונים מסטטי לדינאמי) רעיון ראשון שתי רשימות נתבונן ברשימה מקושרת, שבה כל איבר מצביע לאיבר שאחריו, ולאיבר שלפניו (רשימה מקושרת דו כיוונית). נוסיף רשימה מקושרת נוספת מעליו. רשימה זו תהיה רשימה של "נציגים" של הרשימה המקורית. לא נשמור את כל האיברים ברשימה זו, אלא רק נציגים מהרשימה שמתחתיה. כל נציג יצביע לאיבר שמתחתיו לאיבר האמיתי. כך, כאשר נרצה לבצע חיפוש, נבצע חיפוש רגיל ברשימה מקושרת ברשימת הנציגים. כאשר נמצא את הקודם והעוקב של האיבר אותו אנו מחפשים, נרד לרשימה מתחתיה (שבה כל האיברים) ושם נחפש את האיבר עצמו, בין שני הנציגים. כמה נציגים כדאי לבחור? מה המרחק בין כל שני נציגים? לשאלה השנייה נענה כרגע מרחק אחיד (נעיר שזוהי תשובה אופטימלית בסדר גודל, אם כי, ניתן לשפרה בקבועים ראה בתרגיל). באשר לשאלה הראשונה, נתבונן בעצם כמה עולה לנו חיפוש. תהי L 1 הרשימה המלאה, ותהי L 2 רשימת הנציגים. חיפוש איבר x במבנה הנתונים שיצרנו עולה: T (search 2 ) = L 2 + L 1 L 2 כלומר, במקרה הגרוע ביותר אנו עוברים על כל רשימת הנציגים. לאחר מכן, אנו עוברים על חלק מהרשימה המלאה. מכיוון שחליקנו את הנציגים באופן אחיד, המרחק בין כל שני נציגים הוא 2 L 1 L / (אם נניח ברשימה המלאה יש 20 איברים, וברשימת הנציגים יש 4 איברים, בין כל שני נציגים יש בערך 5 איברים; בכל מעבר ברשימת הנציגים, אנו "מדלגים" על 5 איברים אמיתיים). מתי ביטוי זה מקבל מינימום? ניתן לגזור, את הביטוי, ולגלות כי הביטוי מגיע למינימום כאשר 1 L. 2 = L בצורה זו, חיפוש עולה L 1 2. למעשה, הצלחנו להוריד את זמן החיפוש מ L 1 = n ל L 1 = 2 n 2. סיבוכיות המקום עלתה מ n ל O(n) n, + n = כלומר אין הבדל בסדר גודל בכל הקשור לסיבוכיות מקום. כבר יש לנו שיפור משמעותי ובצורה כללית.. נמשיך לבנות רשימת נציגים לנציגים, נקבל שלוש רמות. נניח שכל רשימה של נציגים מחולקת באופן אחיד. נקבל אם כן, שזמן החיפוש בשלוש רשימות הינו: T (search 3 ) = L 3 + L 2 L 3 + L 1 L 2 18

23 ביטוי זה מקבל מינימום כאשר 1 L 2 = 3 L 1 2, L 3 = 3 L ואז נקבל:.T (search 3 ) = 3 3 n בצורה כללית: T (search 1 ) = n T (search 2 ) = 2 n T (search 3 ) = 3 3 n T (search 4 ) = 4 4 n T (search k ) = k k n.. T (search n ) = n n n = n נשים לב שהביטוי מורכב מ k k n כאשר החלק הראשון במכפלה (k) הוא מספר הרמות, והחלק השני הוא מספר האיברים שמדלגים עליהם בכל רמה. אם כן, מהו מספר הרמות האופטימלי? הביטוי k k n מקבל מינימום כאשר.k = log n במקרה זה נקבל כי,T (search k ) = log n log n n מכיוון שמתקיים = 2 n, log n נקבל כי: 2 n.t (search log n ) = log כלומר, יש לנו במבנה הנתונים log n רמות (רשימות), כל אחת מכילה נציגים של הרמה מתחתיה, והרווח בין כל שני נציגים הוא 2. בצורה כזו, נקבל כי: ברמה התחתונה יהיה כל האיברים. ברמה שמעליה יהיו 1/2 מהאיברים. ברמה שמעליה יהיו 1/4 מהאיברים (חצי מהאיברים שברמה האחת לפני האחרונה). ברמה שמעליה יהיו 1/8 מהאיברים, וכן הלאה. נקבל אם כן, שסיבוכיות הזיכרון היא: n ( ) +... = 2n = O(n) חיפוש איבר עולה לנו (n O(log בדיוק כמו בחיפוש בינארי. נעיר כי מה שהצגנו פה הוא List, Ideal Skip כלומר רשימת דילוגים אידיאלית. לא הראינו כיצד מבצעים insert ו ;delete נעיר שישנם שתי דרכים לבצע זאת: 19 בצורה הסתברותית: כלומר, בכל פעם שמכניסים איבר לרשימה, "מטילים מטבע" בכדי להחליט האם להעלות אותו נציג לרמה למעלה, ובכל שלב מטילים מטבעות האם להמשיך ולהעלות אותו למעלה. בצורה כזו, נקבל כי המרחקים אינם בהכרח בעלי מרחק אחיד, וכמו כן, מספר הרמות יכול להעלות (או להיות קטן יותר) מ (n.o(log על כל פנים, ניתן להוכיח שבהסתברות גבוהה, הכנסה, הוצאה וחיפוש עולים (n.o(log כמו כן, מספר הרמות יהיה (n O(log בהסתברות גבוהה. מכיוון שהסטודנטים בשלב זה לא למדו הסתברות ברמה מספיקה לשם ניתוח מבנה הנתונים, אנו נאלצים שלא להראות את הפעולות הנ"ל, והניתוח למקרה זה, ולכן מסתפקים רק במבנה נתונים סטאטי... בצורת ניתוח לשיעורין: ניתן להתחיל עם skip list אידיאלי, ולאחר מכן להכניס איברים ו"ללכלך" אותו, ולאבד מהאופטימליות שלו. כאשר "מלכלכים" יותר מדי (מתי?) נצטרך לבצע שוב "סדר" ולאזן אותו. בצורה כזו, ניתן להראות שהעלות לשיעורין של כל פעולה היא (n,o(log אם כי, ישנה פעולה פעולת ה"איזון מחדש" שעולה לפעמים יותר; על כל פנים, נבצע אותה פעם אחת בסדרה של הרבה פעולות שנבצע במבנה הנתונים, ולכן בעלות לשיעורין היא "נבלעת".

24 4.3 מחסנית מחסנית היא אוסף סדור של פריטים. ההכנסה וההוצאה נעשית אך ורק דרך ראש המחסנית. הפריט שנכנס לראש המחסנית הינו זה שנמצא בראש המחסנית, ומדיניות ההכנסה וההוצאה של הפריטים במחסנית היא.Last In First Out - LIFO ניתן לבצע גישה במחסנית רק לאיבר הנמצא בראשה. פעולות אפשריות במחסנית: דחיפה (x :push(s, הכנסת אלמנט למחסנית. ההכנסה תתבצע לראש המחסנית. שליפה :pop(s) הוצאת האלמנט שבראש המחסנית. אם המחסנית ריקה פעולה זו גורמת להודעת שגיאה :(exception) stack underflow (חמיקה). האם ריקה :isempty(s) מחזירה האם המחסנית S הינה ריקה. ראש: top(s) מחזירה את האיבר שנמצא בראש המחסנית (ולא מוציאה אותו; זוהי שאילתא). נעיר שעל פי ההגדרה גודל המחסנית אינו מוגבל, ולכן ניתן לבצע את הפעולה push כאוות נפשנו. אך, ייתכן ולפעמים באימלפמנטציות מסויימות נרצה להגביל את גודל המחסנית. במקרה שהמחסנית מלאה, ומישהו מבצע פעולת push נקבל הודעת שגיאה שנקרא.stack overflow כאמור, לעיתים ניתן לקבל גם הודעת,stack underflow בכדי להימנע מכך לפני כל פעולת pop נבצע את פעולת,isEmpty ונבצע את פעולת ה pop אך ורק אם isempty החזיר.false דוגמא לשימוש במחסנית בדיקת חוקיות של סוגריים בהינתן ביטוי הכולל מספר של זוגות סוגריים מקוננים, כיצד נוודא שהסוגריים מקוננים כהלכה? לדוגמא: + 6 5))] (4 + + (3 + 2) [(1 + מקוננים כהלכה. לעומת זאת 5) + 4] [( אינם מקוננים כהלכה. הערה: אם היה קיים רק סוג סוגריים אחד בביטוי, אז ניתן היה לפתור זאת בקלות ללא מחסנית ע"י שימוש במונה (כיצד?). נשים לב שכדי שביטוי יהיה חוקי צריך להתקיים: קיום מספר שווה של סוגריים ימניים ושמאליים. קיום סוגר שמאלי תואם לכל סוגר ימני. לא קיימת רישא של הביטוי שבו מספר הסוגריים הימניים גדול ממספר הסוגריים השמאליים. האלגוריתם: נאתחל מחסנית להיות מחסנית ריקה. נקרא את הביטוי משמאל לימין: ברגע שנתקל בסוגר פותח (סוגר שמאלי) נדחוף אותו למחסנית. ברגע שנתקל בסוגר חותם (סוגר ימני) נבדוק: אם המחסנית ריקה אזי נחזיר "הביטוי לא תקין". אם המחסנית לא ריקה נבדוק האם האיבר הפותח של הסוגריים שבראש המחסנית (הסוגר השמאלי) מתאים לאיבר שאנו מחזיקים כרגע ביד (הסוגר הימני). אם לא נחזיר "הביטוי לא תקין". אחרת נמשיך בסריקה. כאשר סיימנו לקרוא את הביטוי נבדוק את המחסנית. אם היא לא ריקה נחזיר "הביטוי לא תקין" אחרת נחזיר "הביטוי תקין". 20

25 4.3.2 דוגמא לשימוש במחסנית המרת ביטוי מייצוג inf ix לייצוג postf ix ביטוי בצורה inf ix הינו ביטוי (לדוגמא) מהצורה: ביטוי המתאים בצורת postfix נראה כך: 2 (2 + 3) (7 4 2). 2, 3, +, 2,, 3, 4,, +7, 4,, 2,, 6,, 5,, שם של משתנה / מספר נקרא בשם אופרנד. לפעולות עצמן (...,,,+) אנו קוראים בשם אופרטור. ביטוי בצורת inf ix יותר אינטואיטיבי לבני אדם, וכך אנו משתמשים ביום יום. ביטוי בצורת postf ix הינו קל יותר למחשב בשביל לבצע אבלואציה כלומר, בשביל לחשב את הביטוי (תראו בהרצאה שאכן קל לחשב ביטוי כאשר הוא נתון בצורת.(postfix נראה כעת איך ניתן להמיר ביטוי בצורת infix לביטוי ב.postf ix האלגוריתם צריך להתייחס לקדימויות של אופרטורים, קדימויות של סוגריים, לסדר של האופרנדים, וכו'. האלגוריתם: 1: אתחל מחסנית ריקה S (מחסנית האופרטורים). 2: לכל סמל c בביטוי (משמאל לימין): 2.1: אם אופרנד (מספר / משתנה) הדפס c. 2.2: אחרת: (c אופרטור סימן) 2.2.1: כל עוד S לא ריקה ו top(s) קודם ל c: (קודם מבחינת סדר פעולות) :2.2.2 הדפס.pop(S).push(c,S) :2.3 3: כל עוד S לא ריקה הדפס pop(s) במימוש זה התעלמנו בסוגריים. נעיר שבכדי לדעת להעביר גם סוגריים צריך לבצע רקורסיה. דוגמא. נראה דוגמא עבור :3 המחסנית ריקה, מתבוננים באיבר הראשון 3 ומדפיסים אותו. הביטוי המתקבל: 3 רואים אופרטור ( ). המחסנית ריקה מכניסים את למחסנית. רואים אופרנד 4. מדפיסים אותו. מקבלים: 3, 4 רואים אופרטור ( ). בודקים את ראש המחסנית. מגיון שבראש המחסנית יש אופרטור בעל ייחס קדימות ( קודם ל ), מוציאים את מהמחסנית, ומדפיסים אותו. כעת המחסנית ריקה, ומכניסים לתוכה את. נקבל: 3, 4, 3, 4,, 5 רואים 5, מדפיסים אותו. נקבל: 21

26 רואים ( ), בודקים את ראש המחסנית, קודם ל, ולכן רק מכניסים את למחסנית. רואים 6, מדפיסים אותו, ומרוקנים את המחסנית. נקבל: 3, 4,, 5, 6,, 22

27 תרגול 8 Splay Trees 8.1 סקירה כללית במסגרת ההרצאה למדתם עצים מאוזנים, ובפרט עצי.AV L בשיעור זה נלמד עצי.splay trees עצי splay trees הם עצי חיפוש בינאריים, והומצאו בשנת 1985 ע"י Sleator ו T. arjan ראה [5]. עץ חיפוש זה "מאזן את עצמו". בנוסף, הוא בעל תכונה מעניינת שבה האיברים האחרונים שאותם חיפשנו יימצאו בראש העץ (קרובים לשורש), ולכן חיפושם יהיה מהיר. הרעיון הוא שאיבר שחיפשנו לא מזמן כנראה שנחפש אותו שוב בעתיד הקרוב, ולכן נרצה להחזיר אותו ב"מהירות". הפעולה הבסיסית בעצי,splay trees היא הפעולה.splay הפעולה ) T splay(x, מחזירה עץ חיפוש בינארי עם אותם האיברים כמו ב T כך ש x בשורש. אם x לא ב T, בשורש יהיה y כך ש: או ש y הוא הגדול ביותר ב T שקטן מ x (כלומר, מבין כל האיברים ב y T, הוא הקודם ל x). או ש y הוא הקטן ביותר ב T שגדול מ x (כלומר, מבין כל האיברים ב y T, הוא העוקב ל.(x נשים לב ש splay אינה פעולת הכנסה או פעולת הוצאה; זוהי פעולה שרק משנה את צורת העץ. מימוש כל שאר הפעולות על העץ ייעשה בעזרת הפעולה :splay ) T member(x, האם x חלק מהעץ.T בכדי לממש פעולה זו, נבצע ) T,splay(x, אם,x T נקבל כי x בשורש העץ, ולכן נחזיר "כן". אחרת נחזיר "לא". ) T delete(x, מחק את האיבר x מ T. נבצע ) T splay(x, ונקבל חזרה T. למעשה. נקבל עץ שבו x בשורש, וקיים לנו תת עץ שמאלי T, 1 ותת עץ ימני T. 2 נרצה להוציא את x ואיכשהו "לאחד" את שני העצים T. 1, T 2 כיצד נבצע את האיחוד כך שהעץ המתקבל יהיה עץ חיפוש בינארי? ניקח את T. 1 פה כל האיברים קטנים מ x. נבצע ( +,1.splay(T נקבל חזרה T, 1 כך שהאיבר שנמצא בשורש הוא האיבר הגדול ביותר בעץ T. 1 לפיכך, בהכרח, אין לו בן ימני, אלא רק בן שמאלי. כבן ימני "נשתול" את העץ T. 2 העץ שקיבלנו הוא חוקי מכיוון שכל האיברים ב T 1 קטנים מ x, וכל האיברים ב T 2 גדולים מ x. לפיכך, כל האיברים ב T 2 גדולים מהאיבר הגדול ביותר ב T 1 שהוא זה שיימצא בשורש. ) T insert(x, נכניס את x לתוך T כמו כל הכנסה בעץ חיפוש בינארי. לאחר מכן מבצעים פעולת splay בכדי להעלות אותו לשורש. אם כן, הפעולה היחידה שנותרה לנו היא הפעולה (x.splay(t, 8.2 מימוש הפעולה x) splay(t, בפעולה splay מצאנו איבר x (או קודם או עוקב אליו), וכעת רוצים להעלות אותו לראש העץ, כלומר, להופכו לשורש. לשם כך, נעזר בשלוש פעולות Zig Zag,Zig Zig ו.Zig אנו מסתכלים על המסלול בין x לבין 23

28 השורש, ומנתחים את צורת המסלול. אם יש לנו "ימינה ימינה" (או באופן שקול "שמאלה שמאלה") נבצע פעולת.zig zig אם יש לנו "שמאלה ימינה" (או לחילופין "ימינה שמאלה") נבצע פעולת.zig zag כל פעולה שכזו מקפיצה את x שתי רמות לכיוון השורש, ושומרת על העץ כעץ חיפוש בינארי. מכיוון שלא מובטח ש x נמצא ברמה זוגית, נבצע לבסוף פעולת zig שמעבירה אותנו רמה אחת בלבד. אם כן: פעולת :Zig Zig בצורה זו נקפיץ את x שתי רמות למעלה. פעולת :Zig Zag שוב, נקפיץ את x שתי רמות למעלה. פעולת :Zig כעת, נרצה להראות שאם ישנם n איברים בעץ, אזי m פעולות לוקחות לכל היותר (n,o(m log כלומר (n O(log בממוצע לכל פעולה. זהו למעשה ניתוח לשיעורין. כלומר, נראה שבניתוח לשיעורין פעולת.O(log n) לוקחת splay 24

29 8.3 ניתוח פעולת splay ננתח בעזרת שיטת הפוטנציאל. עבור עץ T, נסמן ב ) φ(t את פונקציאת הפוטנציאל. נראה שפונקציאת הפוטנציאל תהיה מינימלית כאשר העץ פחות או יותר מאוזן. בנוסף, פונקציית הפוטנציאל תהיה גדולה כאשר העץ לא מאוזן. לכל קודקוד w בעץ נסמן ב (w) T את תת העץ שהשורש שלו ב w. נגדיר: µ(w) φ(t ) def = log T (w) def = w T µ(w) בדקו שהנכם מבינים מדוע פונקציית הפוטנציאל זו חוקית. (מהי הדרישה?). המחיר לשיעורין של הפעולה splay היא: ĉ(splay(t, x)) = c(splay(t, x)) + φ(t ) φ(t ) כאשר אנו מסמנים ב T את העץ שהתקבל לאחר הפעולה.splay הטענה הבאה אומרת שהמחיר של פעולת splay הוא סכום העלויות לשיעורין של כל פעולת זיג זיג, זיג זג ו זיג שמבצעים במהלך הפעולה.splay פורמלית: טענה 8.1 נניח ש x) splay(t, היא סידרה של פעולות zig) (zig, zig zag, zig.p 1,..., P l אזי העלות לשיעורין של :splay ĉ(splay(t, x)) = l ĉ(p i ) הוכחה: נסמן T i T. = T 0 המצב של העץ לאחר הפעולה P. i נקבל: l ĉ(p i ) = l (c (p i ) + φ (T i ) φ (T i 1 )) = l c(p i ) + φ(t l ) φ(t 0 ) = c(splay(t, x)) + φ(t ) φ(t ) = ĉ(splay(t, x)) לפי הטענה, מספיק להסתכל על כמה עולה על פעולה zig zag,zig zig ו,zig ולהתבונן במספר הפעולות שישנן לנו. נסתכל על הפעולות zig zag,zig zig ו.zig נסמן ב µ(x) את הפוטנציאל של הקודקוד x לפני הפעולה וב (x) µ את הפוטנציאל של x אחרי הפעולה. בצורה דומה נסמן את הנ"ל עבור שאר הקודקדוקים.p, g ניתוח פעולת zig-zag טענה 8.2 בכל תת פעולה P i מסוג zig zag מתקיים: ĉ(zig zag) 3(µ (x) µ(x)) הוכחה: ניזכר בפעולה: 25

30 נזכור כי = 1 zag).c(zig על פי האיור, ניתו לראות כי הפרש הפוטנצילאים הוא: (zig zag) = µ (x) + µ (p) + µ (g) µ(x) µ(p) µ(g) (כי כל שאר העצים,A,B,C D לא השתנו). נשים לב: 1. µ(g) µ. (x) = כלומר הפוטנציאל של x לאחר הפעולה הוא כמו הפוטנציאל של g לפני הפעולה. זאת מכיוון שלפני הפעולה g היה הקודקוד שכל צאצאיו הם כל הקודקודים הנידונים; לאחר הפעולה x הוא הקודקוד הנ"ל. x. הוא האבא של p נובע ממבנה העץ. :µ(x) µ(p) 2..3 (g) µ (x) µ וגם (p).µ (x) µ זאת מכיוון ש x הוא האבא של g ושל,p ולכן בהכרח בעל יותר צאצאים מכל אחד מהם בנפרד.. T (x) 2 T (g) או T (x) 2 T (p).4 בכדי לראות זאת, ניתן להתבונן על המינימלי מבין (g) T ו (p) T. נניח בלי הגבלת הכלליות ש (g) T הוא המינימלי מבינהם. מתקיים: (g), T (p) T ולכן: T (x) = T (p) + T (g) + 1 T (g) + T (g) T (g). המקרה השני מתקבל כאשר (p) T הוא המינימום. ממקרה זה, כאשר נפעיל log ונעבור ל µים, נקבל: + 1 (p) µ (x) µ או + 1 (g).µ (x) µ (zig zag) = µ (x) + µ (p) + µ (g) µ(x) µ(p) µ(g) (1) = µ (p) + µ (g) µ(x) µ(p) (2) (3)+(4) µ (p) + µ (g) µ(x) µ(x) µ (x) + µ (x) 1 µ(x) µ(x) = 2µ (x) 1 2µ(x) = 2(µ (x) µ(x)) 1 נקבל אם כן: הסוגריים מעל השווינים מציינים לפי איזו נקדוה השוויון נכון (ראה למעלה). לכן, העלות לשיעורין של הפעולה :zig zag ĉ(zig zag) = c(zig zag) + (zig zag) 1 + 2(µ (x) µ(x)) 1 = 2(µ (x) µ(x)) 3(µ (x) µ(x)) כאשר האי שיוויון האחרון נכון מכיוון ש µ(x) µ. (x) 26

31 ĉ(zig zig) 3(µ (x) µ(x)) ניתוח פעולת zig-zig טענה 8.3 בכל תת פעולה מסוג zig zig מתקיים: הוכחה: ניזכר בפעולה: (zig zig) = µ (x) + µ (p) + µ (g) µ(x) µ(p) µ(g) מתקיים: שוב, מתקיים 1. µ(g) x µ. (x) = מכיל את כל האיברים ש g החזיק לפני הפעולה. 2. (p) µ (x) µ וגם µ(x).µ(p) > לאחר הפעולה x מכיל יותר איברים מ p. לפני הפעולה ההיפך הוא הנכון..3 נשים לב כי (x). T (x) + T (g) T זאת מכיוון שמתחת ל x ב T ישנם העצים.B,A מתחת,g). (p נמצאים כל העצים הללו, פלוס שני קודקודים T ב x מתחת,C. D נמצאים העצים T ב g אזי מתקיים: T (x) T (x) + T (g) T (x) 2 ( T (x) + T (g) ) 2 = T (x) 2 + T (g) T (x) T (g) 2 T (x) T (g) log T (x) 2 log ( 2 T (x) T (g) ) 2 log T (x) log 2 + log T (x) + log T (g) 2µ (x) 1 + µ(x) + µ (g) 2µ (x) 1 µ(x) µ (g) (zig zig) = µ (x) + µ (p) + µ (g) µ(x) µ(p) µ(g) (1) = µ (p) + µ (g) µ(x) µ(p) (2) (3) µ (x) + µ (g) µ(x) µ(x) µ (x) + (2µ (x) 1 µ(x)) 2 µ(x) = 3 ( µ (x) µ(x) ) 1 אם כן, נשים הכל יחד ונקבל: ולכן: ĉ(zig zig) = c(zig zig) + (zig zig) ( µ (x) µ(x) ) 1 = 3 ( µ (x) µ(x) ) ולכן הטענה מתקיימת. 27

32 8.3.3 ניתוח פעולת zig טענה µ(x)) ĉ(zig) 3(µ (x) הוכחה: ניזכר בפעולה: העלות של הפעולה zig היא: = 1.c(zig) בנוסף: (zig) = µ (x) + µ (p) µ(x) µ(p) 2µ (x) 2µ(x) 3(µ (x) µ(x)) כאשר הצעד האחרון נכון מכיוון ש (x) µ, (p) µ וכמו כן: µ(p).µ(x) נקבל אם כן: ĉ(zig) c(zig) + (zig) 1 + 3(µ (x) µ(x)) סיום הניתוח אנו מוכנים למשפט העיקרי של חלק זה: משפט n) 8.5.ĉ(splay(T, x)) = O(log.ĉ(splay(T, x)) = l ראינו כי לכל,i < l הפעולה היא zig zig או הוכחה: כזכור, הראינו כי (i 1=i ĉ(p,zig zag ולכן: ĉ(p i ) 3(µ (x) µ(x)) בנוסף, עבור,i = l מתקיים: + 1 µ(x)) ĉ(p i ) 3(µ (x) נשנה מעט את הנוטציות. נסמן ב (x) µ i את הפוטנציאל של האיבר x לאחר הפעולה ה i, עבור i < l אם כן, הראינו כי לכל.i {1,..., l} ĉ(p i ) 3(µ i (x) µ i 1 (x)) וכמו כן, עבור i = l נקבל: + 1 (x)).ĉ(p l ) 3(µ l (x) µ l 1 נקבל אם כן כי בסה"כ: ĉ(splay(t, x)) l ĉ(p i ) 3(µ l (x) µ 0 (x)) + 1 3µ l (x) + 1 = 3 log T + 1 = O(log n) 28

33 תרגול 10 עצים אדומים שחורים עצים אדומים שחורים הומצאו ע"י [1], Bayer ב עץ אדום שחור הוא עץ חיפוש בינארי, שבו כל פעולה במקרה הגרוע עולה (n,o(log כאשר n הוא מספר הנתונים בעץ. הפעולות בהן הוא תומך הן,insert.search ו delete עצים אדומים שחורים הם כנראה העצים שבהם משתמשים הכי הרבה ביום יום. בספרייה הסטנדרטית של std :: map בעץ אדום שחור) בכדי לממש את מבני הנתונים (כלומר, rb tree משתמשים ב (ST (L C + + ו.std :: multi map 10.1 סקירה כללית בעץ אדום שחור, כל צומת נצבעת בצבע אדום או שחור (כלומר שומרים סיבית נוספת לכל קודקוד המכילה את צבע הקודקוד). צמתים פנימיים ועלים חיצוניים. לכל צומת בעץ החיפוש נוסיף בנים מדומים, כך שלכל צומת בעץ המקורי יהיו בדיוק 2 בנים. לצמתים המקוריים נקרא "צמתים פנימיים", ולצמתים המדומים נקרא "עלים חיצוניים". נשים לב שכל העלים בעץ שנוצר הם למעשה עלים חיצוניים. בעץ אדום שחור כל הצמתים יהיו צמתים פנימיים, וכל העלים יהיו ערכי NULL (אבל יהיו צבועים בצבע שחור, ולכן אנו זקוקים להם כפי שנראה בהמשך). אנו זקוקים לעלים החיצוניים רק לניתוח; במימוש ניתן להתעלם מהם. עצים אדומים שחורים. עץ חיפוש בינארי ייקרא "עץ אדום שחור" אם הוא מקיים את התכונות הבאות: 1. כל צומת צבוע ב"אדום" או "שחור". 2. כל עלה (NULL) צבוע ב"שחור". 3. אם צומת הוא אדום, אז שני בניו שחורים. 4. כל המסלולים מכל קודקוד לכל העלים שהם צאצאיו, מכילים את אותו המספר של צמתים שחורים. דוגמא לעץ אדום שחור: 29

34 הגדרה 10.1 (גובה שחור) לכל צומת x נגדיר "גובה השחור" hight) (black של x, כמספר הקודקודים השחורים בכל מסלול מצומת x ועד לעלה (לא כולל את הצומת x עצמו). נסמן מספר זה ב.bh(x) לפי תכונה (4), כל המסלולים מקודקוד x מסויים לכל אחד מהעלים שהם צאצאיו מכילים את אותו מספר הקודקודים שחורים, ולכן הגדרה זו מוגדרת היטב. דוגמא. בדוגמא הנתונה לנו, נרשום את כל הקודקודים x כך ש:.(NIL) קודקודים אלו הם כל העלים :bh(x) = 0 1 = :bh(x) הקודקודים 1, 6, 11, 15, 22, 25, 27 (נשים לב שהגדרת bh(x) אומרת כל הקודקודים השחורים עד לעלה מלבד הקודקוד x עצמו), ולכן גם הצמתים 25 15, 11, 1, הם בעלי = 1 bh(x) אף על פי שהם שחורים בעצמם..8, 17, 13 :bh(x) = ניתוח גובה עץ אדום שחור הכללים על עצים אדומים שחורים מספיקים בשביל לנתח את גובה העץ, זאת עוד לפני שראינו כיצד מממשים ושומרים על תכונות וכללים אלו. טענה 10.2 לכל קודקוד x בעץ אדום שחור, תת העץ המושרש ב x מכיל לפחות 1 bh(x) 2 צמתים פנימיים. הוכחה: ההוכחה היא באינדוקציה על גובהו של x. אם x הוא עלה, אזי = 0,bh(x) ותת העץ שלו אינו מכיל צמתים פנימיים. הטענה אומרת שתת העץ מכיל = צמתים פנימיים, ולכן הטענה מתקיימת. צעד האינדוקציה: נניח ש x הוא בעל גובה חיובי. נתבונן בתת עץ ששורשו ב x. מכיוון ש x אינו עלה, יש לו שני בנים, נניח,y. z אזי: אם y אדום, אזי bh(x).bh(y) = אם y שחור, אזי 1 bh(x) bh(y) = (שכן, y שחור, ואינו נספר ב,bh(y) אבל כן נספר ב.(bh(x) הנ"ל נכון גם ל z. לסיכום, נוכל לומר כי 1 bh(x).bh(y) = bh(z) על כל פנים, גם y וגם z, שניהם בעלי רמה נמוכה יותר מהרמה של x, ולכן ניתן להפעיל עליהם את הנחת האינדוקציה. לפי ההנחה, 1 bh(y). T (y) 2 לפי המסקנה שראינו, נקבל כי bh(x) 1 1, T (x) 2 ובואפן דומה bh(x) 1 1. T (z) 2 נקבל אם כן: ( ) T (x) = T (y) + T (x) bh(x) = 2 bh(x) = 2 bh(x) 1 וזה בדיוק מה שהיינו צריכים להוכיח. הטענה הבאה היא ליבו של ניתוח עץ אדום שחור, ומראה שעצים אדומים שחורים הם בעלי רמה נמוכה ויחסית מאוזנים, מה שיראה שביצוע הפעולות הוא (n O(log במקרה הגרוע ביותר. 30

35 טענה 10.3 גובהו של עץ אדום שחור המכיל n צמתים פנימיים הוא לכל היותר: (1 + log(n 2. הוכחה: ההוכחה פשוטה ומבוססת על הטענה הקודמת. נתבונן בעץ אדום שחור כלשהו. נתבונן בשורש, x, ונניח שבעץ h רמות. לפי כלל (3) (לכל קודקוד אדום שני בניו שחורים), נקבל שבכל מסלול פשוט מהשורש לעלה יש לכל הפחות h/2 צמתים שחורים, ולכן h/2.bh(x) לפי הטענה הקודמת, 1 bh(x). T (x) 2 נשים לב ש T, (x) = n ולכן: n 2 bh(x) 1 n bh(x) 2 h/2 h 2 log(n + 1) h 2 log(n + 1) 10.3 רוטציות הרוטציה היחידה שנבצע בעץ אדום שחור היא כמו הפעולה zig בעצי.splay תהיה לנו רוטציה ימנית, ורוטציה שמאלית הכנסה ההכנסה של איבר x לעץ אדום שחור T תעשה באופן הבא: חפש את x ב T, והכנס את x כמו בעץ חיפוש בינארי רגיל. נצבע את הקודקוד באדום. נתקן את העץ להיות שוב עץ אדום שחור. התיקון היא הפעולה המסובכת. נחלק למספר מקרים: אם אין לקודקוד הנכנס אבא כלומר הקודקוד נכנס בתור שורש העץ: במקרה זה אין הפרה של איזשהו כלל. אם אביו של הקודקוד (הנכנס) הוא בצבע שחור אין שום בעיה, פשוט "דחפנו" קודקוד אדום בין שני קודקודים שחורים. שום תכונה לא ניזוקה (בדוק!). נותרנו עם המקרה בו אביו של הקודקוד הנכנס הוא אדום. במקרה זה נפריד בין שלושה מקרים: אם דודו של הקודקוד הנכנס הוא גם אדום, סבו של הקודוקוד הוא שחור (אחרת תכונה 3 מופרת). 31 במקרה זה נוכל פשוט להחליף את הצבעים של הרמה של האבא והדוד, עם הצבע של הסבא. בצורה זו, נשמור על תכונה 4. אך, כעת ייתכן שהקודקוד G הפר את תכונה 3 (במקרה שאביו אדום). לכן, נמשיך הלאה לכיוון השורש כאילו G הוא הקודקוד אותו הכנסנו.

36 במקרה שדוד של הקודוד החדש הוא שחור, לא נוכל להחליף בין הצבעים של האבא והדוד ובין הצבע של הסבא; במקרה שהקודקוד החדש הוא בן ימני של האבא, נבצע רוטציה שמאלית. בצורה זו העלנו את N (הקודקוד החדש) רמה אחת למעלה. נשים לב שתכונה 4 אינה מופרת, אך תכונה 3 עדיין מופרת. כעת, נתייחס לקודקוד P כאל הקודקוד החדש, ובעצם נקבל את המקרה הבא: במקרה זה הקודוק החדש הוא בן שמאלי של האבא, והדוד הוא בצבע שחור, נבצע רוטציה של הקודוק P ימינה. נשים לב שהחלפנו את הצבע של P ו G. כל הדרישות מתקיימות. דוגמא להכנסה עמוד 245 בספר (מבוא לאלגוריתמים, האוניברסיטה הפתוחה, כרך א', מהדורה א'). 32